{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-04-16T02:06:36.155711700Z",
     "start_time": "2024-04-16T02:06:34.957093500Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#1 数据中含有字符串的时候，如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer\n",
    "def dictvec():\n",
    "\n",
    "    dict = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T16:16:23.812832300Z",
     "start_time": "2025-03-28T16:15:53.753906300Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray())\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T13:06:03.947231900Z",
     "start_time": "2025-03-28T13:06:03.921931200Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T13:06:06.813139700Z",
     "start_time": "2025-03-28T13:06:06.765131500Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Dumping model to file cache C:\\Users\\10783\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.641 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T13:07:14.284076500Z",
     "start_time": "2025-03-28T13:07:13.624061700Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T13:07:37.481133700Z",
     "start_time": "2025-03-28T13:07:37.475004800Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n"
     ]
    }
   ],
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-16T03:18:17.831118800Z",
     "start_time": "2024-04-16T03:18:17.807130600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return None\n",
    "\n",
    "\n",
    "stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-16T03:26:04.795065300Z",
     "start_time": "2024-04-16T03:26:04.765081300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                           [-0.26726124, 0.33968311, 0.39223227],\n",
    "                           [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-28T13:41:04.394194800Z",
     "start_time": "2025-03-28T13:41:04.379235300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "1.5555556666666668"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:27:52.239803100Z",
     "start_time": "2024-04-16T03:27:52.199808400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.068779614944516"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:28:08.971612200Z",
     "start_time": "2024-04-16T03:28:08.956621100Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-28T13:40:59.515301Z",
     "start_time": "2025-03-28T13:40:59.480552300Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [4]\n",
      " [1]]\n",
      "The surport is [2]\n"
     ]
    }
   ],
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.6)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-16T06:40:09.206830800Z",
     "start_time": "2024-04-16T06:40:09.185843100Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[ 1.28620952e-15  3.82970843e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    print(np.var(np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]]), axis=0).sum())\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-16T07:03:35.567758500Z",
     "start_time": "2024-04-16T07:03:34.371235200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T07:18:04.787851600Z",
     "start_time": "2024-04-16T07:18:02.684366900Z"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
